#pragma once
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <unistd.h>
#include <sys/stat.h>
#include <memory>
#include <jsoncpp/json/json.h>

namespace aod
{
    class FileUtil
    {
    private:
        std::string _name;
    public:
        FileUtil(const std::string& name)
        :_name(name)
        {}
        bool exists()//判断文件是否存在
        {
            int ret = access(_name.c_str(),0);
            if(ret != 0)
            {
                return false;
            }
            return true;
        }
        size_t size()//获取文件大小
        {
            //判断文件是否存在，不存在则返回0
            if(this->exists() == false)
            {
                return 0;
            }
            struct stat st;
            int ret = stat(_name.c_str(),&st);
            if(ret != 0)
            {
                std::cout << "获取文件信息失败" << std::endl;
                return 0;
            }
            return st.st_size;
        }
        bool getContent(std::string* body)//读取文件数据到body中
        {
            //读取文件内容，写入body
            std::ifstream ifs;
            ifs.open(_name,std::ios::binary);
            if(ifs.is_open() == false)
            {
                std::cout << "文件打开失败" << std::endl;
                return false;
            }
            //打开之后，读取数据文件
            size_t sz = this->size();
            body->resize(sz);
            ifs.read(&(*body)[0],sz);
            if(ifs.good() == false)
            {
                std::cout << "读取文件数据出错" << std::endl;
                ifs.close();
                return false;
            }
            ifs.close();
            return true;
        }
        bool setContent(const std::string& body)//向文件写入数据
        {
            std::ofstream ofs;
            ofs.open(_name,std::ios::binary);
            if(ofs.is_open() == false)
            {
                std::cout << "文件打开失败" << std::endl;
                return false;
            }
            //文件打开成功，body内容写入文件
            ofs.write(body.c_str(),body.size());
            if(ofs.good() == false)
            {
                std::cout << "数据写入文件出错" << std::endl;
                ofs.close();
                return false;
            }
            ofs.close();
            return true;
        }
        bool createDirectory()//针对目录时创建目录
        {
            if(this->exists())
            {
                return true;
            }
            mkdir(_name.c_str(),0777);
            return true;
        }
    };
    class JsonUtil
    {
    public:
        //实现序列化和反序列化
        static bool serialize(const Json::Value& value,std::string* str)
        {
            Json::StreamWriterBuilder swb;
            std::unique_ptr<Json::StreamWriter> sw(swb.newStreamWriter());
            std::stringstream ss;
            int ret = sw->write(value,&ss);
            if(ret != 0)
            {
                std::cout << "序列化失败" << std::endl;
                return false;
            }
            
        }
        static bool unSerialize(const std::string& str,Json::Value* value)
        {
            Json::CharReaderBuilder crb;
            std::unique_ptr<Json::CharReader> cr(crb.newCharReader());
            std::string err;
            bool ret = cr->parse(str.c_str(),str.c_str()+str.size(),value,&err);
            if(ret == false)
            {
                std::cout << "反序列化失败" << std::endl;
                return false;
            }
            return true;
        }
    };
}